﻿//using Castle.DynamicProxy;
//using System;
//using System.Collections;
//using System.Linq;
//using System.Reflection;
//using System.Text;

//namespace Light.Aop
//{

//    /// <summary>
//    /// 缓存拦截接口
//    /// </summary>
//    public interface ICacheInterceptor : IInterceptor
//    {

//    }


//    /// <summary>
//    /// 基于IOC缓存拦截器 ，依赖 Castle.Windsor、Castle.Core
//    /// </summary>
//    public class CacheInterceptor : ICacheInterceptor
//    {
//        public void Intercept(IInvocation invocation)
//        {
//            try
//            {
//                #region

//                MethodInfo method = null;
//                if (invocation.Arguments.Length == 0)
//                {
//                    method = invocation.InvocationTarget.GetType().GetMethod(invocation.Method.Name);
//                }
//                else
//                {
//                    Type[] types = invocation.Arguments.Select(p => p.GetType()).ToArray();
//                    method = invocation.InvocationTarget.GetType().GetMethod(invocation.Method.Name, types);
//                }
//                CacheMethodAttribute attr = method.GetCustomAttribute<CacheMethodAttribute>();
//                if (attr != null)
//                {
//                    try
//                    {
//                        using (ServiceStack.Redis.IRedisClient redis = Light.Cache.RedisHelper.GetClient())
//                        {
//                            bool isUpdate = attr.UpdateCache;
//                            string keyPrefix = Helper.GetKeyPrefix(method, attr);

//                            if (isUpdate && !String.IsNullOrEmpty(keyPrefix)) //删除缓存，下次查询时，重新获取最新数据
//                            {
//                                var keys = redis.GetAllKeys();
//                                foreach (var key in keys)
//                                {
//                                    if (key.StartsWith(keyPrefix))
//                                    {
//                                        redis.Remove(key);
//                                    }
//                                }
//                                invocation.Proceed();
//                            }
//                            else //尝试读取缓存，读不到，则从数据库获取并添加缓存
//                            {
//                                double expiresSeconds = attr.ExpiresSeconds;
//                                string key = keyPrefix + "_" + Helper.GetCacheKey(invocation);

//                                var ser = new ServiceStack.Redis.Support.ObjectSerializer();
//                                var value = redis.Get<byte[]>(key);
//                                if (value == null || value.Length == 0)
//                                {
//                                    invocation.Proceed();
//                                    redis.Set(key, ser.Serialize(invocation.ReturnValue), TimeSpan.FromSeconds(expiresSeconds));
//                                }
//                                else
//                                {
//                                    invocation.ReturnValue = ser.Deserialize(value);
//                                }
//                            }
//                        }
//                    }
//                    catch
//                    {
//                        invocation.Proceed();
//                    }
//                }
//                else
//                {
//                    invocation.Proceed();
//                }

//                #endregion
//            }
//            catch (Exception ex)
//            {
//                Light.Utility.TextHelper.Console("aop.log", ex.Message, true);
//                invocation.Proceed();
//            }
//        }


//        /// <summary>
//        /// 缓存Key,由类完整名+方法名+参数MD5值（依赖Castle）
//        /// </summary>
//        /// <param name="invocation"></param>
//        /// <returns></returns>
//        public static string GetCacheKey(Castle.DynamicProxy.IInvocation invocation)
//        {
//            return invocation.InvocationTarget.ToString() + "_" + invocation.Method.Name + "_" + GetMD5(invocation.Arguments);
//        }

//        private static string GetMD5(object obj)
//        {
//            try
//            {
//                StringBuilder pwd = new StringBuilder();
//                System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();

//                var ser = new ServiceStack.Redis.Support.ObjectSerializer();
//                byte[] s = md5.ComputeHash(ser.Serialize(obj));

//                for (int i = 0; i < s.Length; i++)
//                {
//                    pwd.Append(s[i].ToString("x").PadLeft(2, '0'));
//                }
//                return pwd.ToString();
//            }
//            catch (Exception ex)
//            {
//                Light.Utility.TextHelper.Console("aop.log", ex.Message, true);
//                return obj.ToString();
//            }

//        }
//    }
//}


//用法

//[Castle.Core.Interceptor(typeof(Light.Aop.ICacheInterceptor))]
//public class AdminUserComponent : BaseComponent<AdminUser>, IAdminUserComponent
//{

        //[Light.Aop.CacheMethod(UpdateCache = true, Type = typeof(AdminUser))]
        //public override OperateResult Update(AdminUser obj)
        //{
        //    UpdateColumn uc = new UpdateColumn(typeof(AdminUser));
        //    uc.IsManyToManyUpdate = obj.IsRoleEditing;

        //    return base.Update(obj, uc);
        //}

//}


//<!-- 配置-->
//<!--<component id="ICacheInterceptor"
//       service="Light.Aop.ICacheInterceptor,Light.Aop"
//       type="Light.Aop.CacheInterceptor,Light.Aop" />-->
